The use of the world wide web (WWW) is increasing rapidly, and so of course is the demand for intelligent systems and software which can permit users to better and more easily explore the offerings of the same. To access information on the WWW, a user typically utilizes a browser program having a graphical interface (such as those offered by such companies as Sun, Microsoft, and Netscape to name a few) to establish an electronic connection between his/her local client computing system, and a remote server system located at an ISP (Internet Service Provider). After such connection is made, the user can then perform a number of operations through the browser, including such tasks as uploading/downloading files (including text, graphics, audio, video, etc.) and even executing programs located on such remote server. The ability to execute programs retrieved from a remote ISP is in fact one of the greater attractions and promises of the WWW. By having a repository which is accessible to millions of users simultaneously, program authors have an opportunity to expand the distribution and use of their products at a level far beyond that previously attainable.
Recently, a type of programming method that has become popular commercially is the use of so-called Java® applets for running programs within conventional web browsers. Java® applets are akin to Java® applications, but the former are specifically designed to interoperate with graphical user interfaces such as the conventional browsers mentioned above. Applets are extremely popular programming methods today also due to the fact that they provide program authors with the tools to create multi-media programs quickly, easily, and with far more capability than conventional HTML based applications. In fact, Java® applets offer a superior interactive experience to the user, allowing users to work fluidly and dynamically with information, and without forcing them to wait continually for web pages to load and re-load.
Despite their many advantages, however, applets have some limitations which so far have prohibited their use on an even greater scale. For instance, for various security reasons, the authors of Java® intentionally constrained applets to operate in what is conventionally known as a “sand box.” In other words, applets were imbued with substantial functionality, but they are not permitted, for example, to do such things as read or write from file systems outside their own domain. So, in the case of a remotely downloaded applet embodying some code which the user desires to execute, such applet cannot read or write from computing systems other than the host from which it originated. This significantly restricts the ability of an applet to perform functions that can be performed by more primitive programming techniques, such as HTML. For a general discussion of the basic limitation of applets, please see “An Introduction to Computer Science—Using Java” by Kamin et. al., McGraw-Hill (1998).
To get around these restrictions, various prior art techniques have been proposed for permitting applets to access resources outside of their download host, through the use of so-called “proxies.” This approach allows applets to behave more like any other conventional HTML based code, so that the user is given additional functionality in an invisible and seamless fashion. An example of such proxies can be found at the following locations on the internet: (1) wwwdotwebreferencedotcom/dev/proxy; which contains an article by Kyle Downey entitled “Getting out of the Sandbox: Building an Applet Proxy Server” and (2) wwwdotgamelandotcom/experts/java/answers88dothtml by Leihai Xu. The first reference contains a reasonably detailed explanation of how a “Quotron” applet could be implemented so that even if it was downloaded from a particular host server (e.g., domain A) it could still access quote information from a computing system operated by Yahoo! in a manner transparent to the user. A proxy connection is set up in the host server by the applet, which retrieves the quote information on behalf of the applet, thus preventing the applet from violating its access restrictions.
Most destination sites rely on advertising sales (banners, buttons, and text ads) as their main revenue stream, and naturally one goal is to maximize the exposure of ads to the site's audience. The restriction on applets currently makes them undesirable for advertising for a number of reasons. First, they only communicate to their host and thus they do not work well with advertising content that is based at so-called “ad servers” such as those run by such companies as Doubleclick, AdForce, etc., either locally or at a third party server. This is because the advertising content is located at such ad servers, not at the host from which the applet was downloaded. As a general trend, most destination site operators are moving to local and remote third party ad servers, because they are more easy to use, and allow more ad capability. This means that operators of host server systems are caught in a dilemma between providing the most interesting and dynamic computing experience for their users (which are applet based applications), and the need to generate advertising revenue from sponsors (which can only be done with ad servers that are incompatible with applet based applications).
Applets do have some ad content handling capability, but it is limited. To some extent, even certain types of conventional graphical content can cause trouble when used within an applet. Applets are called into conventional web pages, and be floated on top of them as well. The applet can invoke page changes, but there is no way for an applet to refresh an ad without reloading the applet again. To refresh the applet means that a reload and restart of the applet must be done, causing significant delay and frustration to the user. Furthermore, fairness to the advertisers must be considered, as advertisers want to be assured that the audience is actually engaged in viewing the web site and the advertiser's ad. Standard practice is that ads are reviewed with each page view, triggered by the user clicking a link or loading a new page. Unfortunately, some sites have resorted to automatically refreshing an applet (and even HTML based) banner ads at fixed time intervals (on the order of 15 seconds to 1 minute). This approach is unfair to advertisers, because leaving a page open will generate ad impressions, even if no one is using the computer. Thus, the present limitations on applets are being addressed in a fashion that cheats advertisers out of their ad dollars, because impressions are not accurately tallied.
As a result of this technical limitation, applets do not enjoy the kind of advertising exposure capability as conventional HTML coded applications. In other words, every new invoked HTML based page can change and display a new banner ad dynamically. These ad exposures by the user can be measured and used to determine some appropriate compensation from the ad sponsor to the host system operator. In contrast, in a page executing a conventional applet based application, the ad does not change, regardless of how long the applet is running, or how many times it is run. An example of a prior art applet for ads is available at: wwwdotjavasoftdotcom/openstudio/applets/bannerdothtml, under the name “Javabanner.” Notably, however, this applet does not use a proxy, and does not know how to handle cookies from an ad server. It simply includes the ads as part of the hard wired parameters for the applet; accordingly, it is not dynamically loaded with ads over time, which is a significant limitation.
Clearly, therefore, there exists a current and pressing need to imbue applets with the capability to display ads in a more flexible and convenient manner that does not require significant delays.
Another related problem associated with advertising with Java applets relates to the fact user “clickthrough” is also not well handled. Click-through describes an action such as when a user clicks on an ad banner and is hyperlinked to a URL associated with the ad. Most ad servers require a click-through URL to “redirect” through the ad server. In other words, the user typically is sent to the ad server with the first request and then is (invisibly to the user) redirected to the payee site. In transit, this click to the ad is counted in the ad server. A recent growing trend seen in the industry is the requirement by ad servers that they download a “cookie” along with the ad, so that after the banner is downloaded, a subsequent click-through is identified via the cookie. In other words, the user first establishes an identity by downloading the ad banner and its cookie, and that identity (the cookie) is used when the user clicks on the ad, causing a call back to the server for the redirection (and supplying the cookie back to the server). Accurate counting of click-throughs is critical in contemporary internet advertising programs, because many common benchmark tools for evaluating advertising effectiveness, prevalence, etc., are based on such events, and their origin.
Cookies (and of course clickthroughs based on cookies) are especially difficult to handle when using java applets. This is because, even though the applet is embedded in the browser, it does do not have free access to all cookies because of standard industry cookie security restrictions. These restrictions, implemented by most commercial browsers, restrict a particular destination site to read only cookie(s) already created by that site. In other words, one site cannot read another site's cookies.
Thus, in the context of ads downloaded through applets from third party ad servers, a cookie received via a proxy cannot be “planted” in the browser because the applet itself does not come from the (proxied) web site. Accordingly, many otherwise useful java applet applications are not implemented on a widespread scale due to this limitation.
Therefore, there is another extremely urgent need in the industry for a way to permit applets to properly handle click-through by users on java based advertising banners.